using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.InteropServices;
using System.Security.Cryptography;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using Microsoft.International.Converters.PinYinConverter;
using Microsoft.International.Converters.TraditionalChineseToSimplifiedConverter;
using System.Net.Mime;

namespace Publicuse.Util
{
  public static class StringUtil
  {

    //所有汉字首字母
    private static char[] firsten =
    {
      'Z',
      'Y',
      'X',
      'W',
      'T',
      'S',
      'R',
      'Q',
      'P',
      'O',
      'N',
      'M',
      'L',
      'K',
      'J',
      'H',
      'G',
      'F',
      'E',
      'D',
      'C',
      'B',
      'A'
    };

    public static bool _windows = RuntimeInformation.IsOSPlatform(OSPlatform.Windows);

    public static string ReplacePath(this string path)
    {
      if (string.IsNullOrEmpty(path))
        return "";
      if (_windows)
        return path.Replace("/", "\\");
      return path.Replace("\\", "/");
    }

    /// <summary>
    /// 字符串转Unicode码
    /// </summary>
    /// <returns>The to unicode.</returns>
    /// <param name="value">Value.</param>
    public static string StringToUnicode(this string value)
    {
      //不保留斜杆\
      byte[] bytes = Encoding.Unicode.GetBytes(value);
      StringBuilder stringBuilder = new StringBuilder();
      for (int i = 0; i < bytes.Length; i += 2)
      {
        // 取两个字符，每个字符都是右对齐。
        stringBuilder.AppendFormat(
          "u{0}{1}",
          bytes[i + 1].ToString("x").PadLeft(2, '0'),
          bytes[i].ToString("x").PadLeft(2, '0')
        );
      }
      return stringBuilder.ToString();

      //保留斜杆\
      //byte[] bytes = Encoding.Unicode.GetBytes(value);
      //StringBuilder stringBuilder = new StringBuilder();
      //for (int i = 0; i < bytes.Length; i += 2)
      //{
      //    stringBuilder.AppendFormat("\\u{0}{1}", bytes[i + 1].ToString("x").PadLeft(2, '0'), bytes[i].ToString("x").PadLeft(2, '0'));
      //}
      //return stringBuilder.ToString();
    }

    /// <summary>
    /// Unicode转字符串
    /// </summary>
    /// <returns>The to string.</returns>
    /// <param name="unicode">Unicode.</param>
    public static string UnicodeToString(this string unicode)
    {
      string resultStr = "";
      string[] strList = unicode.Split('u');
      for (int i = 1; i < strList.Length; i++)
      {
        resultStr += (char)int.Parse(strList[i], System.Globalization.NumberStyles.HexNumber);
      }
      return resultStr;
    }

    /// <summary>
    /// 字符串转16进制字节数组
    /// </summary>
    /// <param name="hexString"></param>
    /// <returns></returns>
    public static byte[] strToToHexByte(this string hexString)
    {
      hexString = hexString.Replace(" ", "");
      if ((hexString.Length % 2) != 0)
        hexString += " ";
      byte[] returnBytes = new byte[hexString.Length / 2];
      for (int i = 0; i < returnBytes.Length; i++)
        returnBytes[i] = Convert.ToByte(hexString.Substring(i * 2, 2), 16);
      return returnBytes;
    }

    /// <summary>
    /// 字节数组转16进制字符串
    /// </summary>
    /// <param name="bytes"></param>
    /// <returns></returns>
    public static string byteToHexStr(this byte[] bytes)
    {
      string returnStr = "";
      if (bytes != null)
      {
        for (int i = 0; i < bytes.Length; i++)
        {
          returnStr += bytes[i].ToString("X2");
        }
      }
      return returnStr;
    }

    /// <summary>
    /// 字符串转16进制
    /// </summary>
    /// <param name="Data"></param>
    /// <returns></returns>
    public static string Data_Hex_Asc(this string Data)
    {
      string Data1 = "";
      string sData = "";
      while (Data.Length > 0)
      {
        Data1 = System.Convert.ToChar(System.Convert.ToUInt32(Data.Substring(0, 2), 16)).ToString();
        sData = sData + Data1;
        Data = Data.Substring(2, Data.Length - 2);
      }
      return sData;
    }

    /// <summary>
    /// 首字符小写
    /// </summary>
    /// <param name="str"></param>
    /// <returns></returns>
    public static string FirstCharToLower(this string str)
    {
      if (str == null)
        return null;

      if (str.Length > 1)
        return char.ToLower(str[0]) + str.Substring(1);

      return str.ToUpper();
    }

    /// <summary>
    /// 首字符大写
    /// </summary>
    /// <param name="str"></param>
    /// <returns></returns>
    public static string FirstCharToUpper(this string str)
    {
      if (str == null)
        return null;

      if (str.Length > 1)
        return char.ToUpper(str[0]) + str.Substring(1);

      return str.ToUpper();
    }

    /// <summary>
    /// 汉字转化为拼音首字母大写
    /// </summary>
    /// <param name="str">汉字</param>
    /// <returns>全拼</returns>
    public static string GetPinyinToFirstUpper(this string str)
    {
      string r = string.Empty;
      foreach (char obj in str)
      {
        try
        {
          ChineseChar chineseChar = new ChineseChar(obj);
          string t = chineseChar.Pinyins[0].ToString();
          r += t.Substring(0, t.Length - 1).ToLower().FirstCharToUpper();
        }
        catch
        {
          r += obj.ToString();
        }
      }
      return r;
    }

    public static string getSpell(string cnChar)
    {
      byte[] arrCN = Encoding.Default.GetBytes(cnChar);
      if (arrCN.Length > 1)
      {
        int area = (short)arrCN[0];
        int pos = (short)arrCN[1];
        int code = (area << 8) + pos;
        int[] areacode =
        {
          45217,
          45253,
          45761,
          46318,
          46826,
          47010,
          47297,
          47614,
          48119,
          48119,
          49062,
          49324,
          49896,
          50371,
          50614,
          50622,
          50906,
          51387,
          51446,
          52218,
          52698,
          52698,
          52698,
          52980,
          53689,
          54481
        };
        for (int i = 0; i < 26; i++)
        {
          int max = 55290;
          if (i != 25)
            max = areacode[i + 1];
          if (areacode[i] <= code && code < max)
          {
            return Encoding.Default.GetString(new byte[] { (byte)(65 + i) });
          }
        }
        return "*";
      }
      else
        return cnChar;
    }

    /// <summary>
    /// 汉字转化为拼音
    /// </summary>
    /// <param name="str">汉字</param>
    /// <returns>全拼</returns>
    public static string GetPinyin(this string str)
    {
      string r = string.Empty;
      foreach (char obj in str)
      {
        try
        {
          ChineseChar chineseChar = new ChineseChar(obj);
          string t = chineseChar.Pinyins[0].ToString();
          r += t.Substring(0, t.Length - 1).ToLower().FirstCharToUpper();
        }
        catch
        {
          r += obj.ToString();
        }
      }
      return r.ToLower();
    }

    /// <summary>
    /// 汉字转化为拼音首字母
    /// </summary>
    /// <param name="str">汉字</param>
    /// <returns>首字母</returns>
    public static string GetFirstPinyin(this string str)
    {
      string r = string.Empty;
      foreach (char obj in str)
      {
        try
        {
          string t = string.Empty;
          ChineseChar chineseChar = new ChineseChar(obj);
          if (chineseChar.Pinyins.Count > 1)
          {
            if (!string.IsNullOrEmpty(chineseChar.Pinyins[1]))
            {
              t = chineseChar.Pinyins[1].ToString();
            }
            else
            {
              t = chineseChar.Pinyins[0].ToString();
            }
          }
          else
          {
            t = chineseChar.Pinyins[0].ToString();
          }
          r += t.Substring(0, 1);
        }
        catch
        {
          r += obj.ToString();
        }
      }
      return r;
    }

    // <summary>
    /// 简体转换为繁体
    /// </summary>
    /// <param name="str">简体字</param>
    /// <returns>繁体字</returns>
    public static string GetTraditional(this string str)
    {
      string r = string.Empty;
      r = ChineseConverter.Convert(str, ChineseConversionDirection.SimplifiedToTraditional);
      return r;
    }

    /// <summary>
    /// 繁体转换为简体
    /// </summary>
    /// <param name="str">繁体字</param>
    /// <returns>简体字</returns>
    public static string GetSimplified(string str)
    {
      string r = string.Empty;
      r = ChineseConverter.Convert(str, ChineseConversionDirection.TraditionalToSimplified);
      return r;
    }

    /// <summary>
    /// MD5加密
    /// </summary>
    /// <param name="str">字符串</param>
    /// <returns></returns>
    public static string MD5Encrypt(this string phrase)
    {
      UTF8Encoding encoder = new UTF8Encoding();
      MD5CryptoServiceProvider md5hasher = new MD5CryptoServiceProvider();
      byte[] hashedDataBytes = md5hasher.ComputeHash(encoder.GetBytes(phrase));
      return byteArrayToString(hashedDataBytes);
    }

    private static string byteArrayToString(byte[] inputArray)
    {
      StringBuilder output = new StringBuilder("");

      for (int i = 0; i < inputArray.Length; i++)
      {
        output.Append(inputArray[i].ToString("X2"));
      }

      return output.ToString();
    }

    /// <summary>
    /// 基于Sha1的自定义加密字符串方法：输入一个字符串，返回一个由40个字符组成的十六进制的哈希散列（字符串）。
    /// </summary>
    /// <param name="str">要加密的字符串</param>
    /// <returns>加密后的十六进制的哈希散列（字符串）</returns>
    public static string Sha1(this string str)
    {
      var buffer = Encoding.UTF8.GetBytes(str);
      var data = SHA1.Create().ComputeHash(buffer);

      var sb = new StringBuilder();
      foreach (var t in data)
      {
        sb.Append(t.ToString("X2"));
      }

      return sb.ToString();
    }

    /// <summary>
    /// SHA1 加密，返回大写字符串
    /// </summary>
    /// <param name="content">需要加密字符串</param>
    /// <param name="encode">指定加密编码</param>
    /// <returns>返回40位大写字符串</returns>
    public static string toSHA1(this string content, Encoding encode)
    {
      try
      {
        SHA1 sha1 = new SHA1CryptoServiceProvider();
        byte[] bytes_in = encode.GetBytes(content);
        byte[] bytes_out = sha1.ComputeHash(bytes_in);
        sha1.Dispose();
        string result = BitConverter.ToString(bytes_out);
        result = result.Replace("-", "");
        return result;
      }
      catch (Exception ex)
      {
        throw new Exception("SHA1加密出错：" + ex.Message);
      }
    }

    /// <summary>
    /// 字符串去除所有空格取消换行
    /// </summary>
    /// <param name="str"></param>
    /// <returns></returns>
    public static string stringRT(this string str)
    {
      if (!string.IsNullOrEmpty(str))
      {
        return str.TrimEnd('&').Trim().Replace("\n", "").Replace(" ", "");
      }
      else
      {
        return string.Empty;
      }
    }

    /// <summary>
    /// 判断字符是否为空
    /// </summary>
    /// <param name="list"></param>
    /// <returns></returns>
    public static bool isHaveNull(this List<string> list)
    {
      var isHaveNull = false;
      foreach (var item in list)
      {
        if (string.IsNullOrEmpty(item))
        {
          isHaveNull = true;
          break;
        }
      }
      return isHaveNull;
    }

    /// <summary>
    /// 判断集合数据是否为空
    /// </summary>
    /// <param name="list"></param>
    /// <returns></returns>
    public static bool isHaveNull(params string[] list)
    {
      var isHaveNull = false;
      foreach (var item in list)
      {
        if (string.IsNullOrEmpty(item))
        {
          isHaveNull = true;
          break;
        }
      }
      return isHaveNull;
    }

    /// <summary>
    /// 判断值是否为空
    /// </summary>
    /// <param name="value"></param>
    /// <param name="action"></param>
    public static void SetValue(this string value, Action<string> action)
    {
      if (
        !string.IsNullOrEmpty(value)
        || string.Equals(value, "string", StringComparison.OrdinalIgnoreCase)
      )
      {
        action.Invoke(value);
      }
    }

    /// <summary>
    /// 判断值是否为空
    /// </summary>
    /// <param name="value"></param>
    /// <returns></returns>
    public static bool IsNull(this string value)
    {
      if (
        string.IsNullOrEmpty(value)
        || string.Equals(value, "string", StringComparison.OrdinalIgnoreCase)
      )
      {
        return true;
      }
      else
      {
        return false;
      }
    }

    /// <summary>
    /// 判断两个值是否相等
    /// </summary>
    /// <param name="value"></param>
    /// <param name="query"></param>
    /// <param name="action"></param>
    public static void IsEqual(
      this string value,
      string query,
      Action<string> action,
      Action<string> actionb
    )
    {
      if (string.Compare(query, value, true) != 0)
      {
        action.Invoke(value);
      }
      else
      {
        actionb.Invoke(value);
      }
    }

    /// <summary>
    /// 过滤对象数组的重复数据
    /// </summary>
    /// <typeparam name="TSource"></typeparam>
    /// <typeparam name="TKey"></typeparam>
    /// <param name="source"></param>
    /// <param name="keySelector"></param>
    /// <returns></returns>
    public static IEnumerable<TSource> DistinctByb<TSource, TKey>(
      this IEnumerable<TSource> source,
      Func<TSource, TKey> keySelector
    )
    {
      HashSet<TKey> seenKeys = new HashSet<TKey>();
      foreach (TSource element in source)
      {
        if (seenKeys.Add(keySelector(element)))
        {
          yield return element;
        }
      }
    }

    /// <summary>
    /// 根据文件名称返回文件类型
    /// </summary>
    /// <param name="filename"></param>
    /// <returns></returns>
    public static string GetFileType(this string filename)
    {
      var contentType = MimeMapping.MimeUtility.GetMimeMapping(filename);
      return contentType;
    }

    /// <summary>
    /// 时间戳13位
    /// </summary>
    /// <returns></returns>
    public static long GetTimestamp13()
    {
      TimeSpan ts = DateTime.Now.ToUniversalTime() - new DateTime(1970, 1, 1); //ToUniversalTime()转换为标准时区的时间,去掉的话直接就用北京时间
      return (long)ts.TotalMilliseconds; //精确到毫秒 13位
    }

    /// <summary>
    /// 时间戳10位
    /// </summary>
    /// <returns></returns>
    public static long GetTimestamp10()
    {
      TimeSpan ts = DateTime.Now.ToUniversalTime() - new DateTime(1970, 1, 1); //ToUniversalTime()转换为标准时区的时间,去掉的话直接就用北京时间
      return (long)ts.TotalSeconds; //获取10位
    }

    /// <summary>
    /// 13位时间戳Timestamp转换成日期
    /// </summary>
    /// <param name="timeStamp"></param>
    /// <returns></returns>
    public static DateTime Time13ToDateTime(this long timeStamp)
    {
      DateTime dtStart = TimeZone.CurrentTimeZone.ToLocalTime(new DateTime(1970, 1, 1));
      long lTime = long.Parse(timeStamp + "0000");
      TimeSpan toNow = new TimeSpan(lTime);
      return dtStart.Add(toNow);
    }

    /// <summary>
    /// 10位时间戳Timestamp转换成日期
    /// </summary>
    /// <param name="timeStamp"></param>
    /// <returns></returns>
    public static DateTime Time10ToDateTime(this long timeStamp)
    {
      DateTime dtStart = TimeZone.CurrentTimeZone.ToLocalTime(new DateTime(1970, 1, 1));
      return dtStart.AddSeconds(timeStamp);
    }

    /// <summary>
    /// 根据文件名称返回文件类型
    /// </summary>
    /// <param name="filename"></param>
    /// <returns></returns>
    public static string GetFileTypeb(this string filename)
    {
      string mime = string.Empty;
      IDictionary<string, string> _mappings = new Dictionary<string, string>(
        StringComparer.InvariantCultureIgnoreCase
      )
      {
        #region Big freaking list of mime types     
        // combination of values from Windows 7 Registry and
        // from C:\Windows\System32\inetsrv\config\applicationHost.config
        // some added, including .7z and .dat
        { ".323", "text/h323" },
        { ".3g2", "video/3gpp2" },
        { ".3gp", "video/3gpp" },
        { ".3gp2", "video/3gpp2" },
        { ".3gpp", "video/3gpp" },
        { ".7z", "application/x-7z-compressed" },
        { ".apk", "application/vnd.android.package-archive" },
        { ".aa", "audio/audible" },
        { ".AAC", "audio/aac" },
        { ".aaf", "application/octet-stream" },
        { ".aax", "audio/vnd.audible.aax" },
        { ".ac3", "audio/ac3" },
        { ".aca", "application/octet-stream" },
        { ".accda", "application/msaccess.addin" },
        { ".accdb", "application/msaccess" },
        { ".accdc", "application/msaccess.cab" },
        { ".accde", "application/msaccess" },
        { ".accdr", "application/msaccess.runtime" },
        { ".accdt", "application/msaccess" },
        { ".accdw", "application/msaccess.webapplication" },
        { ".accft", "application/msaccess.ftemplate" },
        { ".acx", "application/internet-property-stream" },
        { ".AddIn", "text/xml" },
        { ".ade", "application/msaccess" },
        { ".adobebridge", "application/x-bridge-url" },
        { ".adp", "application/msaccess" },
        { ".ADT", "audio/vnd.dlna.adts" },
        { ".ADTS", "audio/aac" },
        { ".afm", "application/octet-stream" },
        { ".ai", "application/postscript" },
        { ".aif", "audio/x-aiff" },
        { ".aifc", "audio/aiff" },
        { ".aiff", "audio/aiff" },
        { ".air", "application/vnd.adobe.air-application-installer-package+zip" },
        { ".amc", "application/x-mpeg" },
        { ".application", "application/x-ms-application" },
        { ".art", "image/x-jg" },
        { ".asa", "application/xml" },
        { ".asax", "application/xml" },
        { ".ascx", "application/xml" },
        { ".asd", "application/octet-stream" },
        { ".asf", "video/x-ms-asf" },
        { ".ashx", "application/xml" },
        { ".asi", "application/octet-stream" },
        { ".asm", "text/plain" },
        { ".asmx", "application/xml" },
        { ".aspx", "application/xml" },
        { ".asr", "video/x-ms-asf" },
        { ".asx", "video/x-ms-asf" },
        { ".atom", "application/atom+xml" },
        { ".au", "audio/basic" },
        { ".avi", "video/x-msvideo" },
        { ".axs", "application/olescript" },
        { ".bas", "text/plain" },
        { ".bcpio", "application/x-bcpio" },
        { ".bin", "application/octet-stream" },
        { ".bmp", "image/bmp" },
        { ".c", "text/plain" },
        { ".cab", "application/octet-stream" },
        { ".caf", "audio/x-caf" },
        { ".calx", "application/vnd.ms-office.calx" },
        { ".cat", "application/vnd.ms-pki.seccat" },
        { ".cc", "text/plain" },
        { ".cd", "text/plain" },
        { ".cdda", "audio/aiff" },
        { ".cdf", "application/x-cdf" },
        { ".cer", "application/x-x509-ca-cert" },
        { ".chm", "application/octet-stream" },
        { ".class", "application/x-java-applet" },
        { ".clp", "application/x-msclip" },
        { ".cmx", "image/x-cmx" },
        { ".cnf", "text/plain" },
        { ".cod", "image/cis-cod" },
        { ".config", "application/xml" },
        { ".contact", "text/x-ms-contact" },
        { ".coverage", "application/xml" },
        { ".cpio", "application/x-cpio" },
        { ".cpp", "text/plain" },
        { ".crd", "application/x-mscardfile" },
        { ".crl", "application/pkix-crl" },
        { ".crt", "application/x-x509-ca-cert" },
        { ".cs", "text/plain" },
        { ".csdproj", "text/plain" },
        { ".csh", "application/x-csh" },
        { ".csproj", "text/plain" },
        { ".css", "text/css" },
        { ".csv", "text/csv" },
        { ".cur", "application/octet-stream" },
        { ".cxx", "text/plain" },
        { ".dat", "application/octet-stream" },
        { ".datasource", "application/xml" },
        { ".dbproj", "text/plain" },
        { ".dcr", "application/x-director" },
        { ".def", "text/plain" },
        { ".deploy", "application/octet-stream" },
        { ".der", "application/x-x509-ca-cert" },
        { ".dgml", "application/xml" },
        { ".dib", "image/bmp" },
        { ".dif", "video/x-dv" },
        { ".dir", "application/x-director" },
        { ".disco", "text/xml" },
        { ".dll", "application/x-msdownload" },
        { ".dll.config", "text/xml" },
        { ".dlm", "text/dlm" },
        { ".doc", "application/msword" },
        { ".docm", "application/vnd.ms-word.document.macroEnabled.12" },
        { ".docx", "application/vnd.openxmlformats-officedocument.wordprocessingml.document" },
        { ".dot", "application/msword" },
        { ".dotm", "application/vnd.ms-word.template.macroEnabled.12" },
        { ".dotx", "application/vnd.openxmlformats-officedocument.wordprocessingml.template" },
        { ".dsp", "application/octet-stream" },
        { ".dsw", "text/plain" },
        { ".dtd", "text/xml" },
        { ".dtsConfig", "text/xml" },
        { ".dv", "video/x-dv" },
        { ".dvi", "application/x-dvi" },
        { ".dwf", "drawing/x-dwf" },
        { ".dwp", "application/octet-stream" },
        { ".dxr", "application/x-director" },
        { ".eml", "message/rfc822" },
        { ".emz", "application/octet-stream" },
        { ".eot", "application/octet-stream" },
        { ".eps", "application/postscript" },
        { ".etl", "application/etl" },
        { ".etx", "text/x-setext" },
        { ".evy", "application/envoy" },
        { ".exe", "application/octet-stream" },
        { ".exe.config", "text/xml" },
        { ".fdf", "application/vnd.fdf" },
        { ".fif", "application/fractals" },
        { ".filters", "Application/xml" },
        { ".fla", "application/octet-stream" },
        { ".flr", "x-world/x-vrml" },
        { ".flv", "video/x-flv" },
        { ".fsscript", "application/fsharp-script" },
        { ".fsx", "application/fsharp-script" },
        { ".generictest", "application/xml" },
        { ".gif", "image/gif" },
        { ".group", "text/x-ms-group" },
        { ".gsm", "audio/x-gsm" },
        { ".gtar", "application/x-gtar" },
        { ".gz", "application/x-gzip" },
        { ".h", "text/plain" },
        { ".hdf", "application/x-hdf" },
        { ".hdml", "text/x-hdml" },
        { ".hhc", "application/x-oleobject" },
        { ".hhk", "application/octet-stream" },
        { ".hhp", "application/octet-stream" },
        { ".hlp", "application/winhlp" },
        { ".hpp", "text/plain" },
        { ".hqx", "application/mac-binhex40" },
        { ".hta", "application/hta" },
        { ".htc", "text/x-component" },
        { ".htm", "text/html" },
        { ".html", "text/html" },
        { ".htt", "text/webviewhtml" },
        { ".hxa", "application/xml" },
        { ".hxc", "application/xml" },
        { ".hxd", "application/octet-stream" },
        { ".hxe", "application/xml" },
        { ".hxf", "application/xml" },
        { ".hxh", "application/octet-stream" },
        { ".hxi", "application/octet-stream" },
        { ".hxk", "application/xml" },
        { ".hxq", "application/octet-stream" },
        { ".hxr", "application/octet-stream" },
        { ".hxs", "application/octet-stream" },
        { ".hxt", "text/html" },
        { ".hxv", "application/xml" },
        { ".hxw", "application/octet-stream" },
        { ".hxx", "text/plain" },
        { ".i", "text/plain" },
        { ".ico", "image/x-icon" },
        { ".ics", "application/octet-stream" },
        { ".idl", "text/plain" },
        { ".ief", "image/ief" },
        { ".iii", "application/x-iphone" },
        { ".inc", "text/plain" },
        { ".inf", "application/octet-stream" },
        { ".inl", "text/plain" },
        { ".ins", "application/x-internet-signup" },
        { ".ipa", "application/x-itunes-ipa" },
        { ".ipg", "application/x-itunes-ipg" },
        { ".ipproj", "text/plain" },
        { ".ipsw", "application/x-itunes-ipsw" },
        { ".iqy", "text/x-ms-iqy" },
        { ".isp", "application/x-internet-signup" },
        { ".ite", "application/x-itunes-ite" },
        { ".itlp", "application/x-itunes-itlp" },
        { ".itms", "application/x-itunes-itms" },
        { ".itpc", "application/x-itunes-itpc" },
        { ".IVF", "video/x-ivf" },
        { ".jar", "application/java-archive" },
        { ".java", "application/octet-stream" },
        { ".jck", "application/liquidmotion" },
        { ".jcz", "application/liquidmotion" },
        { ".jfif", "image/pjpeg" },
        { ".jnlp", "application/x-java-jnlp-file" },
        { ".jpb", "application/octet-stream" },
        { ".jpe", "image/jpeg" },
        { ".jpeg", "image/jpeg" },
        { ".jpg", "image/jpg" },
        { ".js", "application/x-javascript" },
        { ".jsx", "text/jscript" },
        { ".jsxbin", "text/plain" },
        { ".latex", "application/x-latex" },
        { ".library-ms", "application/windows-library+xml" },
        { ".lit", "application/x-ms-reader" },
        { ".loadtest", "application/xml" },
        { ".lpk", "application/octet-stream" },
        { ".lsf", "video/x-la-asf" },
        { ".lst", "text/plain" },
        { ".lsx", "video/x-la-asf" },
        { ".lzh", "application/octet-stream" },
        { ".m13", "application/x-msmediaview" },
        { ".m14", "application/x-msmediaview" },
        { ".m1v", "video/mpeg" },
        { ".m2t", "video/vnd.dlna.mpeg-tts" },
        { ".m2ts", "video/vnd.dlna.mpeg-tts" },
        { ".m2v", "video/mpeg" },
        { ".m3u", "audio/x-mpegurl" },
        { ".m3u8", "audio/x-mpegurl" },
        { ".m4a", "audio/m4a" },
        { ".m4b", "audio/m4b" },
        { ".m4p", "audio/m4p" },
        { ".m4r", "audio/x-m4r" },
        { ".m4v", "video/x-m4v" },
        { ".mac", "image/x-macpaint" },
        { ".mak", "text/plain" },
        { ".man", "application/x-troff-man" },
        { ".manifest", "application/x-ms-manifest" },
        { ".map", "text/plain" },
        { ".master", "application/xml" },
        { ".mda", "application/msaccess" },
        { ".mdb", "application/x-msaccess" },
        { ".mde", "application/msaccess" },
        { ".mdp", "application/octet-stream" },
        { ".me", "application/x-troff-me" },
        { ".mfp", "application/x-shockwave-flash" },
        { ".mht", "message/rfc822" },
        { ".mhtml", "message/rfc822" },
        { ".mid", "audio/mid" },
        { ".midi", "audio/mid" },
        { ".mix", "application/octet-stream" },
        { ".mk", "text/plain" },
        { ".mmf", "application/x-smaf" },
        { ".mno", "text/xml" },
        { ".mny", "application/x-msmoney" },
        { ".mod", "video/mpeg" },
        { ".mov", "video/quicktime" },
        { ".movie", "video/x-sgi-movie" },
        { ".mp2", "video/mpeg" },
        { ".mp2v", "video/mpeg" },
        { ".mp3", "audio/mpeg" },
        { ".mp4", "video/mp4" },
        { ".mp4v", "video/mp4" },
        { ".mpa", "video/mpeg" },
        { ".mpe", "video/mpeg" },
        { ".mpeg", "video/mpeg" },
        { ".mpf", "application/vnd.ms-mediapackage" },
        { ".mpg", "video/mpeg" },
        { ".mpp", "application/vnd.ms-project" },
        { ".mpv2", "video/mpeg" },
        { ".mqv", "video/quicktime" },
        { ".ms", "application/x-troff-ms" },
        { ".msi", "application/octet-stream" },
        { ".mso", "application/octet-stream" },
        { ".mts", "video/vnd.dlna.mpeg-tts" },
        { ".mtx", "application/xml" },
        { ".mvb", "application/x-msmediaview" },
        { ".mvc", "application/x-miva-compiled" },
        { ".mxp", "application/x-mmxp" },
        { ".nc", "application/x-netcdf" },
        { ".nsc", "video/x-ms-asf" },
        { ".nws", "message/rfc822" },
        { ".ocx", "application/octet-stream" },
        { ".oda", "application/oda" },
        { ".odc", "text/x-ms-odc" },
        { ".odh", "text/plain" },
        { ".odl", "text/plain" },
        { ".odp", "application/vnd.oasis.opendocument.presentation" },
        { ".ods", "application/oleobject" },
        { ".odt", "application/vnd.oasis.opendocument.text" },
        { ".one", "application/onenote" },
        { ".onea", "application/onenote" },
        { ".onepkg", "application/onenote" },
        { ".onetmp", "application/onenote" },
        { ".onetoc", "application/onenote" },
        { ".onetoc2", "application/onenote" },
        { ".orderedtest", "application/xml" },
        { ".osdx", "application/opensearchdescription+xml" },
        { ".p10", "application/pkcs10" },
        { ".p12", "application/x-pkcs12" },
        { ".p7b", "application/x-pkcs7-certificates" },
        { ".p7c", "application/pkcs7-mime" },
        { ".p7m", "application/pkcs7-mime" },
        { ".p7r", "application/x-pkcs7-certreqresp" },
        { ".p7s", "application/pkcs7-signature" },
        { ".pbm", "image/x-portable-bitmap" },
        { ".pcast", "application/x-podcast" },
        { ".pct", "image/pict" },
        { ".pcx", "application/octet-stream" },
        { ".pcz", "application/octet-stream" },
        { ".pdf", "application/pdf" },
        { ".pfb", "application/octet-stream" },
        { ".pfm", "application/octet-stream" },
        { ".pfx", "application/x-pkcs12" },
        { ".pgm", "image/x-portable-graymap" },
        { ".pic", "image/pict" },
        { ".pict", "image/pict" },
        { ".pkgdef", "text/plain" },
        { ".pkgundef", "text/plain" },
        { ".pko", "application/vnd.ms-pki.pko" },
        { ".pls", "audio/scpls" },
        { ".pma", "application/x-perfmon" },
        { ".pmc", "application/x-perfmon" },
        { ".pml", "application/x-perfmon" },
        { ".pmr", "application/x-perfmon" },
        { ".pmw", "application/x-perfmon" },
        { ".png", "image/png" },
        { ".pnm", "image/x-portable-anymap" },
        { ".pnt", "image/x-macpaint" },
        { ".pntg", "image/x-macpaint" },
        { ".pnz", "image/png" },
        { ".pot", "application/vnd.ms-powerpoint" },
        { ".potm", "application/vnd.ms-powerpoint.template.macroEnabled.12" },
        { ".potx", "application/vnd.openxmlformats-officedocument.presentationml.template" },
        { ".ppa", "application/vnd.ms-powerpoint" },
        { ".ppam", "application/vnd.ms-powerpoint.addin.macroEnabled.12" },
        { ".ppm", "image/x-portable-pixmap" },
        { ".pps", "application/vnd.ms-powerpoint" },
        { ".ppsm", "application/vnd.ms-powerpoint.slideshow.macroEnabled.12" },
        { ".ppsx", "application/vnd.openxmlformats-officedocument.presentationml.slideshow" },
        { ".ppt", "application/vnd.ms-powerpoint" },
        { ".pptm", "application/vnd.ms-powerpoint.presentation.macroEnabled.12" },
        { ".pptx", "application/vnd.openxmlformats-officedocument.presentationml.presentation" },
        { ".prf", "application/pics-rules" },
        { ".prm", "application/octet-stream" },
        { ".prx", "application/octet-stream" },
        { ".ps", "application/postscript" },
        { ".psc1", "application/PowerShell" },
        { ".psd", "application/octet-stream" },
        { ".psess", "application/xml" },
        { ".psm", "application/octet-stream" },
        { ".psp", "application/octet-stream" },
        { ".pub", "application/x-mspublisher" },
        { ".pwz", "application/vnd.ms-powerpoint" },
        { ".qht", "text/x-html-insertion" },
        { ".qhtm", "text/x-html-insertion" },
        { ".qt", "video/quicktime" },
        { ".qti", "image/x-quicktime" },
        { ".qtif", "image/x-quicktime" },
        { ".qtl", "application/x-quicktimeplayer" },
        { ".qxd", "application/octet-stream" },
        { ".ra", "audio/x-pn-realaudio" },
        { ".ram", "audio/x-pn-realaudio" },
        { ".rar", "application/octet-stream" },
        { ".ras", "image/x-cmu-raster" },
        { ".rat", "application/rat-file" },
        { ".rc", "text/plain" },
        { ".rc2", "text/plain" },
        { ".rct", "text/plain" },
        { ".rdlc", "application/xml" },
        { ".resx", "application/xml" },
        { ".rf", "image/vnd.rn-realflash" },
        { ".rgb", "image/x-rgb" },
        { ".rgs", "text/plain" },
        { ".rm", "application/vnd.rn-realmedia" },
        { ".rmi", "audio/mid" },
        { ".rmp", "application/vnd.rn-rn_music_package" },
        { ".roff", "application/x-troff" },
        { ".rpm", "audio/x-pn-realaudio-plugin" },
        { ".rqy", "text/x-ms-rqy" },
        { ".rtf", "application/rtf" },
        { ".rtx", "text/richtext" },
        { ".ruleset", "application/xml" },
        { ".s", "text/plain" },
        { ".safariextz", "application/x-safari-safariextz" },
        { ".scd", "application/x-msschedule" },
        { ".sct", "text/scriptlet" },
        { ".sd2", "audio/x-sd2" },
        { ".sdp", "application/sdp" },
        { ".sea", "application/octet-stream" },
        { ".searchConnector-ms", "application/windows-search-connector+xml" },
        { ".setpay", "application/set-payment-initiation" },
        { ".setreg", "application/set-registration-initiation" },
        { ".settings", "application/xml" },
        { ".sgimb", "application/x-sgimb" },
        { ".sgml", "text/sgml" },
        { ".sh", "application/x-sh" },
        { ".shar", "application/x-shar" },
        { ".shtml", "text/html" },
        { ".sit", "application/x-stuffit" },
        { ".sitemap", "application/xml" },
        { ".skin", "application/xml" },
        { ".sldm", "application/vnd.ms-powerpoint.slide.macroEnabled.12" },
        { ".sldx", "application/vnd.openxmlformats-officedocument.presentationml.slide" },
        { ".slk", "application/vnd.ms-excel" },
        { ".sln", "text/plain" },
        { ".slupkg-ms", "application/x-ms-license" },
        { ".smd", "audio/x-smd" },
        { ".smi", "application/octet-stream" },
        { ".smx", "audio/x-smd" },
        { ".smz", "audio/x-smd" },
        { ".snd", "audio/basic" },
        { ".snippet", "application/xml" },
        { ".snp", "application/octet-stream" },
        { ".sol", "text/plain" },
        { ".sor", "text/plain" },
        { ".spc", "application/x-pkcs7-certificates" },
        { ".spl", "application/futuresplash" },
        { ".src", "application/x-wais-source" },
        { ".srf", "text/plain" },
        { ".SSISDeploymentManifest", "text/xml" },
        { ".ssm", "application/streamingmedia" },
        { ".sst", "application/vnd.ms-pki.certstore" },
        { ".stl", "application/vnd.ms-pki.stl" },
        { ".sv4cpio", "application/x-sv4cpio" },
        { ".sv4crc", "application/x-sv4crc" },
        { ".svc", "application/xml" },
        { ".swf", "application/x-shockwave-flash" },
        { ".t", "application/x-troff" },
        { ".tar", "application/x-tar" },
        { ".tcl", "application/x-tcl" },
        { ".testrunconfig", "application/xml" },
        { ".testsettings", "application/xml" },
        { ".tex", "application/x-tex" },
        { ".texi", "application/x-texinfo" },
        { ".texinfo", "application/x-texinfo" },
        { ".tgz", "application/x-compressed" },
        { ".thmx", "application/vnd.ms-officetheme" },
        { ".thn", "application/octet-stream" },
        { ".tif", "image/tiff" },
        { ".tiff", "image/tiff" },
        { ".tlh", "text/plain" },
        { ".tli", "text/plain" },
        { ".toc", "application/octet-stream" },
        { ".tr", "application/x-troff" },
        { ".trm", "application/x-msterminal" },
        { ".trx", "application/xml" },
        { ".ts", "video/vnd.dlna.mpeg-tts" },
        { ".tsv", "text/tab-separated-values" },
        { ".ttf", "application/octet-stream" },
        { ".tts", "video/vnd.dlna.mpeg-tts" },
        { ".txt", "text/plain" },
        { ".u32", "application/octet-stream" },
        { ".uls", "text/iuls" },
        { ".user", "text/plain" },
        { ".ustar", "application/x-ustar" },
        { ".vb", "text/plain" },
        { ".vbdproj", "text/plain" },
        { ".vbk", "video/mpeg" },
        { ".vbproj", "text/plain" },
        { ".vbs", "text/vbscript" },
        { ".vcf", "text/x-vcard" },
        { ".vcproj", "Application/xml" },
        { ".vcs", "text/plain" },
        { ".vcxproj", "Application/xml" },
        { ".vddproj", "text/plain" },
        { ".vdp", "text/plain" },
        { ".vdproj", "text/plain" },
        { ".vdx", "application/vnd.ms-visio.viewer" },
        { ".vml", "text/xml" },
        { ".vscontent", "application/xml" },
        { ".vsct", "text/xml" },
        { ".vsd", "application/vnd.visio" },
        { ".vsi", "application/ms-vsi" },
        { ".vsix", "application/vsix" },
        { ".vsixlangpack", "text/xml" },
        { ".vsixmanifest", "text/xml" },
        { ".vsmdi", "application/xml" },
        { ".vspscc", "text/plain" },
        { ".vss", "application/vnd.visio" },
        { ".vsscc", "text/plain" },
        { ".vssettings", "text/xml" },
        { ".vssscc", "text/plain" },
        { ".vst", "application/vnd.visio" },
        { ".vstemplate", "text/xml" },
        { ".vsto", "application/x-ms-vsto" },
        { ".vsw", "application/vnd.visio" },
        { ".vsx", "application/vnd.visio" },
        { ".vtx", "application/vnd.visio" },
        { ".wgt", "application/x-gtar" },
        { ".wav", "audio/wav" },
        { ".wave", "audio/wav" },
        { ".wax", "audio/x-ms-wax" },
        { ".wbk", "application/msword" },
        { ".wbmp", "image/vnd.wap.wbmp" },
        { ".wcm", "application/vnd.ms-works" },
        { ".wdb", "application/vnd.ms-works" },
        { ".wdp", "image/vnd.ms-photo" },
        { ".webarchive", "application/x-safari-webarchive" },
        { ".webtest", "application/xml" },
        { ".wiq", "application/xml" },
        { ".wiz", "application/msword" },
        { ".wks", "application/vnd.ms-works" },
        { ".WLMP", "application/wlmoviemaker" },
        { ".wlpginstall", "application/x-wlpg-detect" },
        { ".wlpginstall3", "application/x-wlpg3-detect" },
        { ".wm", "video/x-ms-wm" },
        { ".wma", "audio/x-ms-wma" },
        { ".wmd", "application/x-ms-wmd" },
        { ".wmf", "application/x-msmetafile" },
        { ".wml", "text/vnd.wap.wml" },
        { ".wmlc", "application/vnd.wap.wmlc" },
        { ".wmls", "text/vnd.wap.wmlscript" },
        { ".wmlsc", "application/vnd.wap.wmlscriptc" },
        { ".wmp", "video/x-ms-wmp" },
        { ".wmv", "video/x-ms-wmv" },
        { ".wmx", "video/x-ms-wmx" },
        { ".wmz", "application/x-ms-wmz" },
        { ".wpl", "application/vnd.ms-wpl" },
        { ".wps", "application/vnd.ms-works" },
        { ".wri", "application/x-mswrite" },
        { ".wrl", "x-world/x-vrml" },
        { ".wrz", "x-world/x-vrml" },
        { ".wsc", "text/scriptlet" },
        { ".wsdl", "text/xml" },
        { ".wvx", "video/x-ms-wvx" },
        { ".x", "application/directx" },
        { ".xaf", "x-world/x-vrml" },
        { ".xaml", "application/xaml+xml" },
        { ".xap", "application/x-silverlight-app" },
        { ".xbap", "application/x-ms-xbap" },
        { ".xbm", "image/x-xbitmap" },
        { ".xdr", "text/plain" },
        { ".xht", "application/xhtml+xml" },
        { ".xhtml", "application/xhtml+xml" },
        { ".xla", "application/vnd.ms-excel" },
        { ".xlam", "application/vnd.ms-excel.addin.macroEnabled.12" },
        { ".xlc", "application/vnd.ms-excel" },
        { ".xld", "application/vnd.ms-excel" },
        { ".xlk", "application/vnd.ms-excel" },
        { ".xll", "application/vnd.ms-excel" },
        { ".xlm", "application/vnd.ms-excel" },
        { ".xls", "application/vnd.ms-excel" },
        { ".xlsb", "application/vnd.ms-excel.sheet.binary.macroEnabled.12" },
        { ".xlsm", "application/vnd.ms-excel.sheet.macroEnabled.12" },
        { ".xlsx", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" },
        { ".xlt", "application/vnd.ms-excel" },
        { ".xltm", "application/vnd.ms-excel.template.macroEnabled.12" },
        { ".xltx", "application/vnd.openxmlformats-officedocument.spreadsheetml.template" },
        { ".xlw", "application/vnd.ms-excel" },
        { ".xml", "text/xml" },
        { ".xmta", "application/xml" },
        { ".xof", "x-world/x-vrml" },
        { ".XOML", "text/plain" },
        { ".xpm", "image/x-xpixmap" },
        { ".xps", "application/vnd.ms-xpsdocument" },
        { ".xrm-ms", "text/xml" },
        { ".xsc", "application/xml" },
        { ".xsd", "text/xml" },
        { ".xsf", "text/xml" },
        { ".xsl", "text/xml" },
        { ".xslt", "text/xml" },
        { ".xsn", "application/octet-stream" },
        { ".xss", "application/xml" },
        { ".xtp", "application/octet-stream" },
        { ".xwd", "image/x-xwindowdump" },
        { ".z", "application/x-compress" },
        { ".zip", "application/x-zip-compressed" },
        #endregion
      };
      return _mappings.TryGetValue(filename, out mime) ? mime : "application/octet-stream";
    }

    public static bool IsDate(this string strDate)
    {
      try
      {
        if (strDate.Contains("日"))
          return false;

        var nowtime = Convert.ToDateTime(strDate);
        return true;
      }
      catch
      {
        return false;
      }
    }

    public static long GetLongValue(this string data)
    {
      try
      {
        if (string.IsNullOrEmpty(data))
        {
          return 0;
        }
        else
        {
          return Convert.ToInt64(data);
        }
      }
      catch (Exception ex)
      {
        return 0;
      }
    }

    public static double GetDoubleValue(this string data)
    {
      try
      {
        if (string.IsNullOrEmpty(data))
        {
          return 0;
        }
        else
        {
          return Convert.ToDouble(Convert.ToDouble(data).ToString("F2"));
        }
      }
      catch (Exception ex)
      {
        return 0;
      }
    }

    public static double GetDoubleValue(this string data, int num)
    {
      try
      {
        if (string.IsNullOrEmpty(data))
        {
          return 0;
        }
        else
        {
          return Convert.ToDouble(Convert.ToDouble(data).ToString("F" + num));
        }
      }
      catch (Exception ex)
      {
        return 0;
      }
    }

    public static double GetDoubleValueb(this string data)
    {
      try
      {
        if (string.IsNullOrEmpty(data))
        {
          return 0;
        }
        else
        {
          return Convert.ToDouble(data);
        }
      }
      catch (Exception ex)
      {
        return 0;
      }
    }

    public static double GetDoubleJWDValue(this string data)
    {
      try
      {
        if (string.IsNullOrEmpty(data))
        {
          return 0;
        }
        else
        {
          return Convert.ToDouble(data);
        }
      }
      catch (Exception ex)
      {
        return 0;
      }
    }

    public static int GetIntValue(this string data)
    {
      try
      {
        if (string.IsNullOrEmpty(data))
        {
          return 0;
        }
        else
        {
          return Convert.ToInt32(data);
        }
      }
      catch (Exception ex)
      {
        return 0;
      }
    }

    public static bool CheckInput(this List<double> list)
    {
      var istrue = true;
      foreach (var item in list)
      {
        if (item <= 0)
        {
          istrue = false;
          break;
        }
      }
      return istrue;
    }

    /// <summary>
    /// 根据身份证号码计算年龄和性别
    /// </summary>
    /// <param name="identityCard"></param>
    /// <returns></returns>
    public static BirthdayAgeSex GetBirthdayAgeSex(this string identityCard)
    {
      if (string.IsNullOrEmpty(identityCard))
      {
        return null;
      }
      else
      {
        //身份证长度15位一代身份证,18位位二代;其他不合法
        if (identityCard.Length != 15 && identityCard.Length != 18)
        {
          return null;
        }
      }

      BirthdayAgeSex entity = new BirthdayAgeSex();
      string strSex = string.Empty;

      //处理18位的身份证号码从号码中得到生日和性别代码
      if (identityCard.Length == 18)
      {
        entity.Birthday =
          identityCard.Substring(6, 4)
          + "-"
          + identityCard.Substring(10, 2)
          + "-"
          + identityCard.Substring(12, 2);
        strSex = identityCard.Substring(14, 3);
      }
      if (identityCard.Length == 15)
      {
        entity.Birthday =
          "19"
          + identityCard.Substring(6, 2)
          + "-"
          + identityCard.Substring(8, 2)
          + "-"
          + identityCard.Substring(10, 2);
        strSex = identityCard.Substring(12, 3);
      }

      entity.Age = CalculateAge(entity.Birthday); //根据生日计算年龄
      if (int.Parse(strSex) % 2 == 0) //性别代码为偶数是女性奇数为男性
      {
        entity.Sex = "女";
      }
      else
      {
        entity.Sex = "男";
      }
      return entity;
    }

    /// <summary>
    /// 根据出生日期，计算精确的年龄
    /// </summary>
    /// <param name="birthDate">生日</param>
    /// <returns></returns>
    public static int CalculateAge(string birthDay)
    {
      DateTime birthDate = DateTime.Parse(birthDay);
      DateTime nowDateTime = DateTime.Now;
      int age = nowDateTime.Year - birthDate.Year;
      //再考虑月、天的因素
      if (
        nowDateTime.Month < birthDate.Month
        || (nowDateTime.Month == birthDate.Month && nowDateTime.Day < birthDate.Day)
      )
      {
        age--;
      }
      return age;
    }

    /// <summary>
    /// 过滤特殊字符
    /// </summary>
    /// <param name="str"></param>
    /// <returns></returns>
    public static string ReplaceStrChar(this string str)
    {
      if (str == String.Empty)
        return String.Empty;

      List<string> chartlist = new List<string>()
      {
        "'",
        "‘",
        ";",
        "；",
        ",",
        "?",
        "？",
        "！",
        "<",
        "＜",
        ">",
        "＞",
        "(",
        "(",
        ")",
        ")",
        "@",
        "＠",
        "=",
        "＝",
        "+",
        "＋",
        "*",
        "＊",
        "&",
        "＆",
        "#",
        "＃",
        "%",
        "％",
        "$",
        "￥",
        "（",
        "）"
      };

      foreach (string chart in chartlist)
      {
        str = str.Replace(chart, "");
      }
      return Regex.Replace(str, @"\s", "");
    }

    /// <summary>
    /// 保存2位小数点，如果小数点是0或者00则保存整数部分
    /// </summary>
    /// <param name="dValue"></param>
    /// <returns></returns>
    public static string GetDoubleString(this string dValue)
    {
      var newvalue = dValue.GetDoubleValue().ToString("F2");
      try
      {
        if (string.Compare(newvalue, "NaN", true) == 0)
        {
          newvalue = "0";
        }
        var xsdv = newvalue.Split('.')[1];
        if (xsdv == "00" || xsdv == "0")
        {
          newvalue = newvalue.Split('.')[0];
        }
        if (newvalue.Split('.').Length > 1)
        {
          var newa = newvalue.Split('.')[0];
          var newb = newvalue.Split('.')[1].TrimEnd('0');
          newvalue = newa + "." + newb;
        }
      }
      catch (Exception ex) { }

      return newvalue;
    }
  }

  /// <summary>
  /// 定义 生日年龄性别 实体
  /// </summary>
  public class BirthdayAgeSex
  {
    public string Birthday { get; set; }
    public int Age { get; set; }
    public string Sex { get; set; }
  }
}
